home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / listings / v_09_03 / 9n03074a < prev    next >
Encoding:
Text File  |  1991-01-15  |  4.8 KB  |  227 lines
  1.  
  2. /***************************************/
  3. /*                                     */
  4. /*              osem.c                 */
  5. /*                                     */
  6. /* Operating system emulation routines */
  7. /* for embedded system example ROM     */
  8. /* monitor.                            */
  9. /*                                     */
  10. /*          Copyright (c) 1990         */
  11. /*          Pasquale J. Villani        */
  12. /*          All Rights Reserved        */
  13. /*                                     */
  14. /*                                     */
  15. /***************************************/
  16.  
  17. #include <sys/types.h>
  18. #include <sys/stat.h>
  19. #include <fcntl.h>
  20. #include <errno.h>
  21.  
  22.  
  23. /* convience defines                            */
  24. #define STDIN   0
  25. #define STDOUT  1
  26. #define STDERR  2
  27. #define MAXFD   3
  28. #define BUFSIZ  512         /* buffers are 512 for this vsn */
  29.  
  30. #ifndef TRUE
  31. #define TRUE    1
  32. #endif
  33. #ifndef FALSE
  34. #define FALSE   0
  35. #endif
  36. #ifndef ERROR
  37. #define ERROR   -1
  38. #endif
  39. #ifndef OK
  40. #define OK  0
  41. #endif
  42. #ifndef EOF
  43. #define EOF -1
  44. #endif
  45.  
  46.  
  47. /* make errno accessible to the entire file             */
  48. extern int errno;
  49.  
  50. /* special data structure for ioctl optional argument           */
  51. union arg
  52. {
  53.     int i;
  54.     void    *p;
  55. };
  56.  
  57.  
  58. /* a simple file table to keep track of stdin & stdout status       */
  59. static char fd[MAXFD] =
  60. {
  61.     FALSE,          /* stdin                */
  62.     FALSE,          /* stdout               */
  63.     FALSE           /* stderr               */
  64. };
  65.  
  66.  
  67. /* a simple set of i/o buffers for input buffering          */
  68. struct _buf
  69. {
  70.     int nbytes;
  71.     char    *bp;
  72.     char    buf[BUFSIZ];
  73. };
  74.  
  75. static struct _buf iobuf =
  76. {
  77.     -1, (char *)0
  78. };
  79.  
  80.  
  81.  
  82. /*                                  */
  83. /* smatch:                              */
  84. /*  match two strings. return true if equal             */
  85. /*                                  */
  86. static int smatch(s1, s2)
  87. char *s1, *s2;
  88. {
  89.     while(*s1 != '\0')
  90.     {
  91.         if(*s1 != *s2)
  92.             break;
  93.         ++s1;
  94.         ++s2;
  95.     }
  96.     return s1 == s2;
  97. }
  98.  
  99.  
  100.  
  101. /*                                  */
  102. /* open:                                */
  103. /*  open a file for read or write                   */
  104. /*  follows posix specification                 */
  105. /*                                  */
  106. int open(path, oflag, mode)
  107. char *path;
  108. int oflag, mode;
  109. {
  110.     if(smatch(path, "/dev/con") || ((oflag & O_RDWR) == O_RDWR))
  111.     {
  112.         errno = EACCES;
  113.         return ERROR;       /* error - only console allowed */
  114.     }
  115.     /* for this system, only stdin and stdout are available     */
  116.     /* based on oflag and availability, assign appropraie fd    */
  117.     if((oflag & O_RDONLY) && !fd[STDIN])
  118.     {
  119.         fd[STDIN] = TRUE;
  120.         return STDIN;
  121.     }
  122.     else if(oflag & O_WRONLY)
  123.     {
  124.         fd[STDOUT] = TRUE;
  125.         return STDOUT;
  126.     }
  127.     else
  128.     {
  129.         errno = EACCES;
  130.         return ERROR;
  131.     }
  132. }
  133.  
  134.  
  135. /*                                  */
  136. /* close:                               */
  137. /*  close a file                            */
  138. /*                                  */
  139. int close(fildes)
  140. int fildes;
  141. {
  142.     if((fildes < 0) || (fildes > MAXFD) || !(fd[fildes]))
  143.     {
  144.         errno = EBADF;
  145.         return ERROR;
  146.     }
  147.     fd[fildes] = FALSE;
  148.     return OK;
  149. }
  150.  
  151.  
  152. /*                                  */
  153. /* ioctl:                               */
  154. /*  direct device control                       */
  155. /*                                  */
  156. int ioctl(fildes, request, arg)
  157. int fildes, request;
  158. union arg arg;
  159. {
  160.     errno = EINVAL;
  161.     return ERROR;
  162. }
  163.  
  164.  
  165. /*                                  */
  166. /* write:                               */
  167. /*  write to a file                         */
  168. /*                                  */
  169. int write(fildes, buf, nbyte)
  170. int fildes;
  171. void *buf;
  172. unsigned int nbyte;
  173. {
  174.     int cnt = nbyte;
  175.  
  176.     if(fildes != STDOUT && fildes != STDERR)
  177.     {
  178.         errno = EBADF;
  179.         return ERROR;
  180.     }
  181.     while(cnt-- > 0)
  182.     {
  183.         if(*(char *)buf == '\n')
  184.             _cout('\r');
  185.         _cout(*((char *)buf)++);
  186.     }
  187.     return nbyte;
  188. }
  189.  
  190.  
  191. int read(fildes, buf, nbyte)
  192. int fildes;
  193. void *buf;
  194. unsigned int nbyte;
  195. {
  196.     register char *bp;
  197.     register int c;
  198.  
  199.     if(fildes != STDIN)
  200.     {
  201.         errno = EBADF;
  202.         return ERROR;
  203.     }
  204.     if(iobuf.nbytes <= 0)
  205.     {
  206.         bp = iobuf.buf;
  207.         iobuf.nbytes = 0;
  208.         do
  209.         {
  210.             *bp++ = (_cout(c = _cin()));
  211.             if(c == '\r')
  212.                 _cout('\n');
  213.             ++iobuf.nbytes;
  214.         } while(c != '\n' && c != '\r');
  215.         iobuf.bp = iobuf.buf;
  216.     }
  217.     for(bp = iobuf.bp, c = 0; c < iobuf.nbytes && c <nbyte; c++)
  218.     {
  219.         *((char *)buf)++ = *bp == '\r' ? ++bp, '\n' : *bp++;
  220.     }
  221.         iobuf.bp = bp;
  222.     iobuf.nbytes -= c;
  223.     return c;
  224. }
  225.  
  226.  
  227.